#pragma once

using namespace System::Collections::Generic;
using namespace System;

#include "ValueHelpers.h"

namespace Cephei
{
	public ref class CDouble_Factory : public Double_Factory 
	{
	public:
		virtual IVector<Double>^ CreateVector ()
		{
			return gcnew CoVector<Double> (gcnew CDoubleVector);
		}
		virtual IVector<Double>^ CreateVector (System::Collections::Generic::IEnumerable<Double>^ source)
		{
			return gcnew CoVector<Double> (source, gcnew CDoubleVector ());
		}

		virtual IMatrix<Double>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Double> (gcnew CDoubleMatrix);
		}
		virtual IMatrix<Double>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<Double>^>^ source)
		{
			return gcnew CoMatrix<Double> (source, gcnew CDoubleMatrix ());
		}

		virtual ICube<Double>^ CreateCube ()
		{
			return gcnew CoCube<Double> (gcnew CDoubleCube);
		}
		virtual ICube<Double>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<Double>^>^ source)
		{
			return gcnew CoCube<Double> (source, gcnew CDoubleCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<Double>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Double>^>^> (gcnew CoCellVector<Generic::ICell<Double>^> (gcnew CDoubleVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<Double>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<Double>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Double>^>^> (gcnew CoCellVector<Generic::ICell<Double>^> (source, gcnew CDoubleVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Double>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Double>^>^> (gcnew CoCellMatrix<Generic::ICell<Double>^> (gcnew CDoubleMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Double>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<Double>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Double>^>^> (gcnew CoCellMatrix<Generic::ICell<Double>^> (source, gcnew CDoubleMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Double>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Double>^>^> (gcnew CoCellCube<Generic::ICell<Double>^> (gcnew CDoubleCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Double>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<Double>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Double>^>^> (gcnew CoCellCube<Generic::ICell<Double>^> (source, gcnew CDoubleCube()));
		}
	};


	public ref class CInt_Factory : public Int_Factory 
	{
	public:
		virtual IVector<Int32>^ CreateVector ()
		{
			return gcnew CoVector<Int32> (gcnew CInt32Vector);
		}
		virtual IVector<Int32>^ CreateVector (System::Collections::Generic::IEnumerable<Int32>^ source)
		{
			return gcnew CoVector<Int32> (source, gcnew CInt32Vector ());
		}

		virtual IMatrix<Int32>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Int32> (gcnew CInt32Matrix);
		}
		virtual IMatrix<Int32>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<Int32>^>^ source)
		{
			return gcnew CoMatrix<Int32> (source, gcnew CInt32Matrix ());
		}

		virtual ICube<Int32>^ CreateCube ()
		{
			return gcnew CoCube<Int32> (gcnew CInt32Cube);
		}
		virtual ICube<Int32>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<Int32>^>^ source)
		{
			return gcnew CoCube<Int32> (source, gcnew CInt32Cube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<Int32>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Int32>^>^> (gcnew CoCellVector<Generic::ICell<Int32>^> (gcnew CInt32Vector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<Int32>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<Int32>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Int32>^>^> (gcnew CoCellVector<Generic::ICell<Int32>^> (source, gcnew CInt32Vector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Int32>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Int32>^>^> (gcnew CoCellMatrix<Generic::ICell<Int32>^> (gcnew CInt32Matrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Int32>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<Int32>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Int32>^>^> (gcnew CoCellMatrix<Generic::ICell<Int32>^> (source, gcnew CInt32Matrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Int32>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Int32>^>^> (gcnew CoCellCube<Generic::ICell<Int32>^> (gcnew CInt32Cube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Int32>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<Int32>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Int32>^>^> (gcnew CoCellCube<Generic::ICell<Int32>^> (source, gcnew CInt32Cube()));
		}
	};

	public ref class CUInt_Factory : public UInt_Factory 
	{
	public:
		virtual IVector<UInt32>^ CreateVector ()
		{
			return gcnew CoVector<UInt32> (gcnew CUInt32Vector);
		}
		virtual IVector<UInt32>^ CreateVector (System::Collections::Generic::IEnumerable<UInt32>^ source)
		{
			return gcnew CoVector<UInt32> (source, gcnew CUInt32Vector ());
		}

		virtual IMatrix<UInt32>^ CreateMatrix ()
		{
			return gcnew CoMatrix<UInt32> (gcnew CUInt32Matrix);
		}
		virtual IMatrix<UInt32>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<UInt32>^>^ source)
		{
			return gcnew CoMatrix<UInt32> (source, gcnew CUInt32Matrix ());
		}

		virtual ICube<UInt32>^ CreateCube ()
		{
			return gcnew CoCube<UInt32> (gcnew CUInt32Cube);
		}
		virtual ICube<UInt32>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<UInt32>^>^ source)
		{
			return gcnew CoCube<UInt32> (source, gcnew CUInt32Cube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<UInt32>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<UInt32>^>^> (gcnew CoCellVector<Generic::ICell<UInt32>^> (gcnew CUInt32Vector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<UInt32>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<UInt32>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<UInt32>^>^> (gcnew CoCellVector<Generic::ICell<UInt32>^> (source, gcnew CUInt32Vector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<UInt32>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<UInt32>^>^> (gcnew CoCellMatrix<Generic::ICell<UInt32>^> (gcnew CUInt32Matrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<UInt32>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<UInt32>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<UInt32>^>^> (gcnew CoCellMatrix<Generic::ICell<UInt32>^> (source, gcnew CUInt32Matrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<UInt32>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<UInt32>^>^> (gcnew CoCellCube<Generic::ICell<UInt32>^> (gcnew CUInt32Cube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<UInt32>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<UInt32>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<UInt32>^>^> (gcnew CoCellCube<Generic::ICell<UInt32>^> (source, gcnew CUInt32Cube()));
		}
	};

	public ref class CLong_Factory : public Long_Factory 
	{
	public:
		virtual IVector<Int64>^ CreateVector ()
		{
			return gcnew CoVector<Int64> (gcnew CLongVector);
		}
		virtual IVector<Int64>^ CreateVector (System::Collections::Generic::IEnumerable<Int64>^ source)
		{
			return gcnew CoVector<Int64> (source, gcnew CLongVector ());
		}

		virtual IMatrix<Int64>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Int64> (gcnew CLongMatrix);
		}
		virtual IMatrix<Int64>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<Int64>^>^ source)
		{
			return gcnew CoMatrix<Int64> (source, gcnew CLongMatrix ());
		}

		virtual ICube<Int64>^ CreateCube ()
		{
			return gcnew CoCube<Int64> (gcnew CLongCube);
		}
		virtual ICube<Int64>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<Int64>^>^ source)
		{
			return gcnew CoCube<Int64> (source, gcnew CLongCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<Int64>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Int64>^>^> (gcnew CoCellVector<Generic::ICell<Int64>^> (gcnew CLongVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<Int64>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<Int64>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Int64>^>^> (gcnew CoCellVector<Generic::ICell<Int64>^> (source, gcnew CLongVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Int64>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Int64>^>^> (gcnew CoCellMatrix<Generic::ICell<Int64>^> (gcnew CLongMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Int64>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<Int64>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Int64>^>^> (gcnew CoCellMatrix<Generic::ICell<Int64>^> (source, gcnew CLongMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Int64>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Int64>^>^> (gcnew CoCellCube<Generic::ICell<Int64>^> (gcnew CLongCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Int64>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<Int64>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Int64>^>^> (gcnew CoCellCube<Generic::ICell<Int64>^> (source, gcnew CLongCube()));
		}
	};
	public ref class CULong_Factory : public ULong_Factory 
	{
	public:
		virtual IVector<UInt64>^ CreateVector ()
		{
			return gcnew CoVector<UInt64> (gcnew CULongVector);
		}
		virtual IVector<UInt64>^ CreateVector (System::Collections::Generic::IEnumerable<UInt64>^ source)
		{
			return gcnew CoVector<UInt64> (source, gcnew CULongVector ());
		}

		virtual IMatrix<UInt64>^ CreateMatrix ()
		{
			return gcnew CoMatrix<UInt64> (gcnew CULongMatrix);
		}
		virtual IMatrix<UInt64>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<UInt64>^>^ source)
		{
			return gcnew CoMatrix<UInt64> (source, gcnew CULongMatrix ());
		}

		virtual ICube<UInt64>^ CreateCube ()
		{
			return gcnew CoCube<UInt64> (gcnew CULongCube);
		}
		virtual ICube<UInt64>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<UInt64>^>^ source)
		{
			return gcnew CoCube<UInt64> (source, gcnew CULongCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<UInt64>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<UInt64>^>^> (gcnew CoCellVector<Generic::ICell<UInt64>^> (gcnew CULongVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<UInt64>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<UInt64>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<UInt64>^>^> (gcnew CoCellVector<Generic::ICell<UInt64>^> (source, gcnew CULongVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<UInt64>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<UInt64>^>^> (gcnew CoCellMatrix<Generic::ICell<UInt64>^> (gcnew CULongMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<UInt64>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<UInt64>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<UInt64>^>^> (gcnew CoCellMatrix<Generic::ICell<UInt64>^> (source, gcnew CULongMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<UInt64>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<UInt64>^>^> (gcnew CoCellCube<Generic::ICell<UInt64>^> (gcnew CULongCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<UInt64>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<UInt64>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<UInt64>^>^> (gcnew CoCellCube<Generic::ICell<UInt64>^> (source, gcnew CULongCube()));
		}
	};
	public ref class CDateTime_Factory : public DateTime_Factory 
	{
	public:
		virtual IVector<DateTime>^ CreateVector ()
		{
			return gcnew CoVector<DateTime> (gcnew CDateTimeVector);
		}
		virtual IVector<DateTime>^ CreateVector (System::Collections::Generic::IEnumerable<DateTime>^ source)
		{
			return gcnew CoVector<DateTime> (source, gcnew CDateTimeVector ());
		}

		virtual IMatrix<DateTime>^ CreateMatrix ()
		{
			return gcnew CoMatrix<DateTime> (gcnew CDateTimeMatrix);
		}
		virtual IMatrix<DateTime>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<DateTime>^>^ source)
		{
			return gcnew CoMatrix<DateTime> (source, gcnew CDateTimeMatrix ());
		}

		virtual ICube<DateTime>^ CreateCube ()
		{
			return gcnew CoCube<DateTime> (gcnew CDateTimeCube);
		}
		virtual ICube<DateTime>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<DateTime>^>^ source)
		{
			return gcnew CoCube<DateTime> (source, gcnew CDateTimeCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<DateTime>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<DateTime>^>^> (gcnew CoCellVector<Generic::ICell<DateTime>^> (gcnew CDateTimeVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<DateTime>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<DateTime>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<DateTime>^>^> (gcnew CoCellVector<Generic::ICell<DateTime>^> (source, gcnew CDateTimeVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<DateTime>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<DateTime>^>^> (gcnew CoCellMatrix<Generic::ICell<DateTime>^> (gcnew CDateTimeMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<DateTime>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<DateTime>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<DateTime>^>^> (gcnew CoCellMatrix<Generic::ICell<DateTime>^> (source, gcnew CDateTimeMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<DateTime>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<DateTime>^>^> (gcnew CoCellCube<Generic::ICell<DateTime>^> (gcnew CDateTimeCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<DateTime>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<DateTime>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<DateTime>^>^> (gcnew CoCellCube<Generic::ICell<DateTime>^> (source, gcnew CDateTimeCube()));
		}
	};

	public ref class CString_Factory : public String_Factory 
	{
	public:
		virtual IVector<String^>^ CreateVector ()
		{
			return gcnew CoVector<String^> (gcnew CStringVector);
		}
		virtual IVector<String^>^ CreateVector (System::Collections::Generic::IEnumerable<String^>^ source)
		{
			return gcnew CoVector<String^> (source, gcnew CStringVector ());
		}

		virtual IMatrix<String^>^ CreateMatrix ()
		{
			return gcnew CoMatrix<String^> (gcnew CStringMatrix);
		}
		virtual IMatrix<String^>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<String^>^>^ source)
		{
			return gcnew CoMatrix<String^> (source, gcnew CStringMatrix ());
		}

		virtual ICube<String^>^ CreateCube ()
		{
			return gcnew CoCube<String^> (gcnew CStringCube);
		}
		virtual ICube<String^>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<String^>^>^ source)
		{
			return gcnew CoCube<String^> (source, gcnew CStringCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<String^>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<String^>^>^> (gcnew CoCellVector<Generic::ICell<String^>^> (gcnew CStringVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<String^>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<String^>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<String^>^>^> (gcnew CoCellVector<Generic::ICell<String^>^> (source, gcnew CStringVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<String^>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<String^>^>^> (gcnew CoCellMatrix<Generic::ICell<String^>^> (gcnew CStringMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<String^>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<String^>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<String^>^>^> (gcnew CoCellMatrix<Generic::ICell<String^>^> (source, gcnew CStringMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<String^>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<String^>^>^> (gcnew CoCellCube<Generic::ICell<String^>^> (gcnew CStringCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<String^>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<String^>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<String^>^>^> (gcnew CoCellCube<Generic::ICell<String^>^> (source, gcnew CStringCube()));
		}
	};
	public ref class CBool_Factory : public Bool_Factory 
	{
	public:
		virtual IVector<Boolean>^ CreateVector ()
		{
			return gcnew CoVector<Boolean> (gcnew CBooleanVector);
		}
		virtual IVector<Boolean>^ CreateVector (System::Collections::Generic::IEnumerable<Boolean>^ source)
		{
			return gcnew CoVector<Boolean> (source, gcnew CBooleanVector ());
		}

		virtual IMatrix<Boolean>^ CreateMatrix ()
		{
			return gcnew CoMatrix<Boolean> (gcnew CBooleanMatrix);
		}
		virtual IMatrix<Boolean>^ CreateMatrix (System::Collections::Generic::IEnumerable<IVector<Boolean>^>^ source)
		{
			return gcnew CoMatrix<Boolean> (source, gcnew CBooleanMatrix ());
		}

		virtual ICube<Boolean>^ CreateCube ()
		{
			return gcnew CoCube<Boolean> (gcnew CBooleanCube);
		}
		virtual ICube<Boolean>^ CreateCube (System::Collections::Generic::IEnumerable<IMatrix<Boolean>^>^ source)
		{
			return gcnew CoCube<Boolean> (source, gcnew CBooleanCube());
		}

		virtual Generic::ICell<IVector<Generic::ICell<Boolean>^>^>^ CreateCellVector ()
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Boolean>^>^> (gcnew CoCellVector<Generic::ICell<Boolean>^> (gcnew CBooleanVector()));
		}

		virtual Generic::ICell<IVector<Generic::ICell<Boolean>^>^>^ CreateCellVector (System::Collections::Generic::IEnumerable<Generic::ICell<Boolean>^>^ source)
		{
			return CellBuilder::Instance->Create<IVector<Generic::ICell<Boolean>^>^> (gcnew CoCellVector<Generic::ICell<Boolean>^> (source, gcnew CBooleanVector()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Boolean>^>^>^ CreateCellMatrix ()
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Boolean>^>^> (gcnew CoCellMatrix<Generic::ICell<Boolean>^> (gcnew CBooleanMatrix()));
		}

		virtual Generic::ICell<IMatrix<Generic::ICell<Boolean>^>^>^ CreateCellMatrix (System::Collections::Generic::IEnumerable<IVector<Generic::ICell<Boolean>^>^>^ source)
		{
			return CellBuilder::Instance->Create<IMatrix<Generic::ICell<Boolean>^>^> (gcnew CoCellMatrix<Generic::ICell<Boolean>^> (source, gcnew CBooleanMatrix()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Boolean>^>^>^ CreateCellCube ()
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Boolean>^>^> (gcnew CoCellCube<Generic::ICell<Boolean>^> (gcnew CBooleanCube()));
		}

		virtual Generic::ICell<ICube<Generic::ICell<Boolean>^>^>^ CreateCellCube (System::Collections::Generic::IEnumerable<IMatrix<Generic::ICell<Boolean>^>^>^ source)
		{
			return CellBuilder::Instance->Create<ICube<Generic::ICell<Boolean>^>^> (gcnew CoCellCube<Generic::ICell<Boolean>^> (source, gcnew CBooleanCube()));
		}
	};
}
